/**
 * 数据库列信息解析工具
 * 统一处理不同数据库返回的列信息格式
 */

/**
 * 解析列长度信息，返回适合显示的长度字符串
 * @param {Object} column 列信息
 * @returns {String} 格式化后的长度字符串
 */
export const parseColumnLength = (column) => {
  // 调试输出
  console.log('[parseColumnLength] 输入:', column);
  
  // 优先使用标准化的lengthDisplay字段
  if (column.lengthDisplay) {
    console.log('[parseColumnLength] 使用lengthDisplay:', column.lengthDisplay);
    return column.lengthDisplay;
  }
  
  // 从RawInfo中获取
  if (column.rawInfo && column.rawInfo.lengthDisplay) {
    console.log('[parseColumnLength] 使用rawInfo.lengthDisplay:', column.rawInfo.lengthDisplay);
    return column.rawInfo.lengthDisplay;
  }
  
  // 尝试从fullType解析
  if (column.fullType) {
    // 移除BYTE/CHAR标记，仅保留数字部分
    const match = column.fullType.match(/\(([^)]+?)(?:\s+(?:BYTE|CHAR))?\)/i);
    if (match) {
      console.log('[parseColumnLength] 从fullType解析:', match[1]);
      return match[1];
    }
  }
  
  // 处理特殊情况
  if (column.precision && column.scale && column.scale > 0) {
    const result = `${column.precision},${column.scale}`;
    console.log('[parseColumnLength] 使用precision,scale:', result);
    return result;
  } else if (column.precision) {
    console.log('[parseColumnLength] 使用precision:', column.precision);
    return String(column.precision);
  }
  
  // 最后使用长度字段
  if (column.length) {
    console.log('[parseColumnLength] 使用length:', column.length);
    return String(column.length);
  }
  
  console.log('[parseColumnLength] 无法解析长度，返回空字符串');
  return '';
};

/**
 * 解析字段注释
 * @param {Object} column 列信息
 * @returns {String} 格式化后的注释
 */
export const parseColumnComment = (column) => {
  console.log('[parseColumnComment] 输入:', column);
  
  // 直接访问标准字段
  if (column.comment !== undefined && column.comment !== null) {
    console.log('[parseColumnComment] 使用comment:', column.comment);
    return column.comment;
  }
  
  // 从RawInfo中获取
  if (column.rawInfo && column.rawInfo.comment !== undefined) {
    console.log('[parseColumnComment] 使用rawInfo.comment:', column.rawInfo.comment);
    return column.rawInfo.comment;
  }
  
  // 其他可能的字段名
  if (column.Comment !== undefined && column.Comment !== null) {
    console.log('[parseColumnComment] 使用Comment:', column.Comment);
    return column.Comment;
  }
  
  console.log('[parseColumnComment] 无法解析注释，返回空字符串');
  return '';
};

/**
 * 获取字段语义类型(BYTE/CHAR)
 * @param {Object} column 列信息
 * @param {String} dbType 数据库类型
 * @returns {String|null} 语义类型或null
 */
export const getColumnSemanticType = (column, dbType) => {
  // 仅达梦数据库需要处理语义类型
  if (dbType !== 'dameng') {
    return null;
  }
  
  // 优先使用标准字段
  if (column.semanticType) {
    return column.semanticType;
  }
  
  // 从RawInfo中获取
  if (column.rawInfo && column.rawInfo.semanticType) {
    return column.rawInfo.semanticType;
  }
  
  // 从fullType解析
  if (column.fullType) {
    if (column.fullType.includes('BYTE')) {
      return 'BYTE';
    }
    if (column.fullType.includes('CHAR') && 
        (column.type.toUpperCase() === 'VARCHAR' || 
         column.type.toUpperCase() === 'VARCHAR2' || 
         column.type.toUpperCase() === 'CHAR')) {
      return 'CHAR';
    }
  }
  
  // 默认值
  return 'BYTE';
};

/**
 * 判断是否为字符类型
 * @param {String} type 数据类型
 * @returns {Boolean} 是否字符类型
 */
export const isCharType = (type) => {
  if (!type) return false;
  
  const upperType = type.toUpperCase();
  return upperType.includes('CHAR') || upperType.includes('VARCHAR') || 
         upperType.includes('VARCHAR2');
};

/**
 * 处理可能的空值，提供默认值
 * @param {*} value 输入值
 * @param {*} defaultValue 默认值
 * @returns {*} 处理后的值
 */
export const safeValue = (value, defaultValue = '') => {
  // 检查undefined、null和空字符串
  if (value === undefined || value === null || value === '') {
    return defaultValue;
  }
  return value;
};

/**
 * 生成统一的列模型
 * @param {Object} column 原始列信息
 * @param {String} dbType 数据库类型
 * @returns {Object} 标准化后的列模型
 */
export const createUnifiedColumnModel = (column, dbType) => {
  console.log(`[createUnifiedColumnModel] 开始处理列 ${column.name}, 数据库类型: ${dbType}`);
  
  // 达梦数据库特殊处理
  if (dbType === 'dameng') {
    // 确保所有必要字段存在
    if (column.rawInfo === undefined) {
      column.rawInfo = {};
    }
    
    // 设置默认的语义类型(如果是字符类型且没有设置)
    if (isCharType(column.type) && !column.semanticType) {
      column.semanticType = 'BYTE';
      console.log(`[createUnifiedColumnModel] 为字符类型设置默认语义类型: BYTE`);
    }
    
    // 确保长度值正确
    if (!column.lengthDisplay) {
      column.lengthDisplay = parseColumnLength(column);
      console.log(`[createUnifiedColumnModel] 解析长度: ${column.lengthDisplay}`);
    }
    
    // 确保注释有值
    column.comment = safeValue(column.comment);
    if (column.rawInfo) {
      column.rawInfo.comment = safeValue(column.rawInfo.comment);
    }
  }
  
  const result = {
    ...column,
    displayLength: parseColumnLength(column),
    displayComment: parseColumnComment(column),
    semanticType: getColumnSemanticType(column, dbType),
    // 确保所有必要字段都有有效值
    comment: safeValue(column.comment),
    defaultValue: safeValue(column.defaultValue),
    length: column.length || 0,
  };
  
  console.log(`[createUnifiedColumnModel] 处理结果:`, result);
  return result;
};

/**
 * 处理数据库特定的默认值
 * @param {String} value 默认值
 * @param {String} type 数据类型
 * @param {String} dbType 数据库类型
 * @returns {String} 格式化后的默认值
 */
export const formatDefaultValue = (value, type, dbType) => {
  if (!value) return '';
  
  // 处理特殊默认值
  if (value.toUpperCase() === 'CURRENT_TIMESTAMP') {
    if (dbType === 'dameng') {
      return 'SYSTIMESTAMP';
    }
    return 'CURRENT_TIMESTAMP';
  }
  
  // 为字符类型添加引号
  if (isCharType(type)) {
    return `'${value.replace(/'/g, "''")}'`;
  }
  
  return value;
}; 